package com.wxl.common

import android.app.Activity
import android.app.Application
import android.text.TextUtils
import com.alibaba.fastjson.JSONArray
import com.alibaba.fastjson.JSONObject
import com.wxl.common.http.OkGoApi
import com.wxl.common.life.ActivityCallback
import com.wxl.common.room.entity.*
import com.wxl.common.room.helper.DBHelper
import com.wxl.common.util.ObservableUtil
import com.wxl.common.util.SpUtil

/**
 * create file time : 2021/2/22
 * create user : wxl
 * subscribe :
 */
class AppContext private constructor() {

    private lateinit var context: Application
    private val activityCallback: ActivityCallback = ActivityCallback()


    companion object {
        val appContext = AC.ac
    }

    private object AC {
        val ac = AppContext()
    }

    fun init(context: Application, debug: Boolean) {
        this.context = context
        SpUtil.context = context
        AppConstant.debug = debug
        OkGoApi.api.setBaseUrl(AppConstant.baseUrl, context)
        this.context.registerActivityLifecycleCallbacks(activityCallback)
    }

    fun getApplication(): Application {
        return context
    }


    fun getCurrentActivity(): Activity? {
        return activityCallback.getCurrentActivity()
    }

    /**
     * 保存串口打开结果
     */
    fun saveOpenPortState(success: Boolean) {
        SpUtil.sp.putBoolean("open_port_status", success)
    }

    /**
     * 串口是否打开
     */
    fun isOpenPort(): Boolean {
        return SpUtil.sp.getBoolean("open_port_status")
    }

    /**
     * 保存第一次进入引导页的状态
     */
    fun saveGuide() {
        SpUtil.sp.putBoolean("isGuide", true)
    }

    /**
     * 是否进入引导页
     */
    fun isGuide(): Boolean {
        return SpUtil.sp.getBoolean("isGuide")
    }

    /**
     * 保存起爆器升级状态
     */
    fun saveDetonatorVersion(state: Int) {
        SpUtil.sp.putInt("detonatorUpdate", state)
    }


    /**
     * 获取起爆器升级信息
     */
    fun getDetonatorVersion(): Int {
        return SpUtil.sp.getInt("detonatorUpdate")
    }


    /**
     * 保存起爆器版本号
     */
    fun saveDeviceVersion(version: Int) {
        SpUtil.sp.putInt("deviceVersion", version)
    }

    /**
     * 保存起爆器版本号
     */
    fun getDeviceVersion(): Int {
        return SpUtil.sp.getInt("deviceVersion")
    }

    /**
     * 保存采集器版本
     */
    fun saveCjqVersion(version: Long) {
        SpUtil.sp.putLong("cjqVersion", version)
    }


    /**
     * 获取采集器版本
     */
    fun getCjqVersion(): Long {
        return SpUtil.sp.getLong("cjqVersion")
    }


    /**
     * 保存采集器网络版本
     */
    fun saveCjqNetVersion(version: Long) {
        SpUtil.sp.putLong("cjqNetVersion", version)
    }

    /**
     * 获取采集器网络版本
     */
    fun getCjqNetVersion(): Long {
        return SpUtil.sp.getLong("cjqNetVersion")
    }

    /**
     * 保存采集器title
     */
    fun saveCjqTitle(title: String) {
        SpUtil.sp.put("cjqTitle", title)
    }

    /**
     * 获取采集器title
     */
    fun getCjqTitle(): String {
        return SpUtil.sp.getString("cjqTitle")
    }

    /**
     * 保存账户登陆信息
     */
    fun saveLoginAccount(account: String) {
        SpUtil.sp.put("loginAcc", account)
        saveLoginAccountTime()
    }

    /**
     * 保存账户登陆名字
     */
    fun saveLoginName(name: String) {
        SpUtil.sp.put("loginName", name)
    }

    /**
     * 保存账户登陆名字
     */
    fun getLoginName(): String {
        return SpUtil.sp.getString("loginName")
    }

    /**
     * 保存用户登录信息
     */
    fun saveLoginAcc(u: UserEntity) {
        SpUtil.sp.put("loginU", JSONObject.toJSONString(u))
    }

    /**
     * 获得登录信息
     */
    fun getLoginAcc(): UserEntity? {
        if (!TextUtils.isEmpty(SpUtil.sp.getString("loginU"))) {
            return JSONObject.parseObject(SpUtil.sp.getString("loginU"), UserEntity::class.java)
        }
        return null
    }

    /**
     * 获取当前登陆的账户
     */
    fun getLoginAccount(): String {
        if (AppConstant.isTest) {
            return "522634198402242130"
        } else {
            return SpUtil.sp.getString("loginAcc")
        }
    }

    /**
     * 保存登陆时间
     */
    fun saveLoginAccountTime() {
        SpUtil.sp.putLong("loginAccTime", System.currentTimeMillis())
    }


    /**
     * 检查登陆超时
     */
    fun checkLoginOutTime(): Boolean {
        if (!AppConstant.isTest) {
            return System.currentTimeMillis() - getLoginAccTime() > AppConstant.mLoginLimitTime
        } else {
            return false
        }
    }

    /**
     * 获得登陆时间
     */
    fun getLoginAccTime(): Long {
        return SpUtil.sp.getLong("loginAccTime")
    }

    /**
     * 保存单位授权信息
     */
    fun saveAuthDmInfo(model: UnApplyBlastEntity.LicenseFileModel) {
        SpUtil.sp.put("authDm", JSONObject.toJSONString(model))
    }


    /**
     * 获取授权单位信息
     */
    fun getAuthDmInfo(): UnApplyBlastEntity.LicenseFileModel? {
        val string = SpUtil.sp.getString("authDm")
        if (TextUtils.isEmpty(string)) return null
        return JSONObject.parseObject(string, UnApplyBlastEntity.LicenseFileModel::class.java)
    }

    /**
     * 保存单位名称
     */
    fun saveBlastDwmc(dwmc: String) {
        SpUtil.sp.put("dwmc", dwmc)
    }

    /**
     * 获取单位名称
     */
    fun getBlastDwmc(): String {
        return SpUtil.sp.getString("dwmc")
    }

    /**
     * 保存单位代码
     */
    fun saveBlastDwCode(dwmc: String) {
        SpUtil.sp.put("dwcode", dwmc)
    }

    /**
     * 获取单位代码
     */
    fun getBlastDwCode(): String {
        return SpUtil.sp.getString("dwcode")
    }

    /**
     * 保存授权文件信息
     */
    fun saveAuthBlast(entity: UnApplyBlastEntity) {
        SpUtil.sp.put("authBlastEntity", JSONObject.toJSONString(entity))
    }

    /**
     * 获取授权文件信息
     */
    fun getAuthBlast(): UnApplyBlastEntity? {
        val string = SpUtil.sp.getString("authBlastEntity")
        if (TextUtils.isEmpty(string)) return null
        return JSONObject.parseObject(string, UnApplyBlastEntity::class.java)
    }

    /**
     * 检查采集器是否匹配
     */
    fun matchCjq(title: String, callback: ObservableUtil.Companion.OnNextCallback<Boolean>) {
        if (AppConstant.isTest) {
            callback.onNext(true)
            return
        }
        DBHelper.queryCollector(object :
            ObservableUtil.Companion.OnNextCallback<List<CollectorBean>>() {
            override fun onNext(t: List<CollectorBean>) {
                if (!t.isNullOrEmpty()) {
                    t.forEach {
                        if (TextUtils.equals(title, it.title)) {
                            callback.onNext(true)
                            return
                        }
                    }
                }
                callback.onNext(false)
            }
        })
    }


    /**
     * 保存是否写入延时
     */
    fun saveIsOpenInputDelayData(isDelay: Boolean) {
        SpUtil.sp.putBoolean("isDelay", isDelay)
    }

    /**
     * 是否开启写入延时
     */
    fun getIsOpenInputDelayData(): Boolean {
        return SpUtil.sp.getBoolean("isDelay")
    }


    /**
     * 保存测试方案
     */
    fun saveTestModel(model: Int) {
        SpUtil.sp.putInt("testModel", model)
    }

    /**
     * 获取测试方案
     */
    fun getTestModel(): Int {
        return SpUtil.sp.getInt("testModel")
    }


    /**
     * 保存最大可组网雷管数
     */
    fun saveLeiGuanMaxNum(num: Int) {
        SpUtil.sp.putInt("lgmn", num)
    }

    /**
     * 获得最多可组网雷管数
     */
    fun getLeiGuanMaxNum(): Int {
        if (SpUtil.sp.getInt("lgmn") <= 0) {
            return 600
        }
        return SpUtil.sp.getInt("lgmn")
    }

    /**
     * 设置是否为单机模式
     */
    fun setCheckModel(isOff: Boolean) {
        SpUtil.sp.putBoolean("isCheckModel", isOff)
    }

    /**
     * 是否为单机模式
     */
    fun isCheckModel(): Boolean {
        return SpUtil.sp.getBoolean("isCheckModel")
    }

    /**
     * 保存经纬度
     */
    fun saveLonLat(lan: Double, lat: Double) {
        SpUtil.sp.put("lon", lan.toString())
        SpUtil.sp.put("lat", lat.toString())
    }

    fun getLon(): Double {
        val lon = SpUtil.sp.getString("lon")
        if (!TextUtils.isEmpty(lon)) {
            return lon.toDouble()
        }
        if (AppConstant.isTest) {
            return 114.065
        }
        return 0.0
    }

    fun getLat(): Double {
        val lat = SpUtil.sp.getString("lat")
        if (!TextUtils.isEmpty(lat)) {
            return lat.toDouble()
        }
        if (AppConstant.isTest) {
            return 22.511
        }
        return 0.0
    }

    /**
     * 获得图片基础地址
     */
    fun getImgBaseUrl(): String {

        return ""
    }

    /**
     * 是否自动下传方案
     */
    fun saveAutoUnderPlan(isAuto: Boolean) {
        SpUtil.sp.putBoolean("isAutoUnderPlan", isAuto)
    }

    /**
     * 是否自动下传方案
     */
    fun isAutoUnderPlan(): Boolean {
        return SpUtil.sp.getBoolean("isAutoUnderPlan")
    }


    /**
     * 是否显示设置下传
     */
    fun saveShowSetUnder(isShow: Boolean) {
        SpUtil.sp.putBoolean("isShowSetUnder", isShow)
    }

    /**'
     * 是否显示设置下传
     */
    fun isShowSetUnder(): Boolean {
        return SpUtil.sp.getBoolean("isShowSetUnder")
    }

    /**
     * 保存自动下传数据
     */
    fun saveAutoUnderData(data: String) {
        SpUtil.sp.put("autoUnderData", data)
    }


    /**
     * 获取自动下传数据
     */
    fun getAutoUnderData(): String {
        return SpUtil.sp.getString("autoUnderData")
    }

    /**
     * 设置是否是夜间模式
     */
    fun setDayNight(isDay: Boolean) {
        SpUtil.sp.putBoolean("isDay", isDay)
    }

    /**
     * 是否为日间模式
     */
    fun isDayModel(): Boolean {
        return SpUtil.sp.getBoolean("isDay")
    }

    /**
     * 存延时雷管数据
     */
    fun setLeiGuanDelayEntity(key: String, data: ArrayList<LeiGuanDelayEntity>) {
        SpUtil.sp.put(key, JSONArray.toJSONString(data))
    }

    /**
     * 获取延时雷管数据
     */
    fun getLeiGuanDelayEntity(key: String): ArrayList<LeiGuanDelayEntity> {
        val s = SpUtil.sp.getString(key)
        if (!TextUtils.isEmpty(s)) {
            return JSONArray.parseArray(
                s,
                LeiGuanDelayEntity::class.java
            ) as ArrayList<LeiGuanDelayEntity>
        }
        return arrayListOf()
    }


    /**
     * 存雷管数据
     */
    fun setLeiGuanEntity(key: String, data: ArrayList<LeiGuanEntity>) {
        SpUtil.sp.put(key, JSONArray.toJSONString(data))
    }

    /**
     * 获取雷管数据
     */
    fun getLeiGuanEntity(key: String): ArrayList<LeiGuanEntity> {
        val s = SpUtil.sp.getString(key)
        if (!TextUtils.isEmpty(s)) {
            return JSONArray.parseArray(
                s,
                LeiGuanEntity::class.java
            ) as ArrayList<LeiGuanEntity>
        }
        return arrayListOf()
    }

}